package com.kuang.service.category;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.kuang.entity.Category;
import com.kuang.mapper.CategoryMapper;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements CategoryService {


    /**

     * @description:查询旅游产品对应的分类信息
     * @author 飞哥yykk
     * @date 2021/8/29 23:39
     * @return
     * @throws
     * 分析：
     * 1：分类的表的数据其实不会很大?
     * 2: 不需要考虑什么分页的问题?
     * 3: 如果形成tree结构呢？
     * 思路：
     * 1：查询一级分类 where pid = 0;
     * 2: 循环查询对应pid=一级分类的id的数据，然后放入到集合中
     * 解决方案：
     * 1: 把数据库的数据全部查询出来
     * 2：可以使用java8的stream的filter方法、map方法、sorted方法进行数据的过滤和重新架子啊
     */
    @Override
    public List<Category> findCategoryTrees() {
        // 1: 设置查询条件,要把发布status=1的查询出来，并且要进行排序subjectSort排升序
        LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(Category::getStatus,1);
        lambdaQueryWrapper.orderByAsc(Category::getSubjectSort);
        // 2 :查询所有的分类数据
        List<Category> allCategories = this.list(lambdaQueryWrapper);
        if(CollectionUtils.isEmpty(allCategories))return Collections.emptyList();
        // 3: 把查询出来的数据，subjectPid=0 一级分类过滤出来 --- filter
        List<Category> resultCategoryList =
                // 这里查询所有的一级分类
                allCategories.stream().filter(rootCategory -> rootCategory.getSubjectPid().equals(0L))
                        // 这里就把一级分类的属性进行扩展和改造
                        .map(category -> {
                            category.setChildrenList(getChildrenMenu(category,allCategories));
                            return category;
                        }).sorted((menu1, menu2) -> {
                    return menu1.getSubjectSort() - menu2.getSubjectSort();
                }).collect(Collectors.toList());
        // 5: 返回结果 ---collect
        return resultCategoryList;
    }


    /**
     * 查询所有的子分类
     *
     * @param rootCategory
     * @param allCategorys
     * @return
     */
    private List<Category> getChildrenMenu(Category rootCategory, List<Category> allCategorys) {
        List<Category> categoryList = allCategorys.stream().filter(cate -> {
            return rootCategory.getSubjectId().equals(cate.getSubjectPid());
        }).collect(Collectors.toList());
        return CollectionUtils.isEmpty(categoryList) ? Collections.emptyList() : categoryList;
    }


    public List<Map<String, Object>> findCategoryTreesMap() {
        // 1：设置查询条件
        LambdaQueryWrapper<Category> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        // 2: 查询所有的分类
        List<Map<String, Object>> categories = this.baseMapper.selectMaps(lambdaQueryWrapper);

        if (categories != null && categories.size() > 0) {
            // 3 : 组装数据
            List<Map<String, Object>> rootCategorys = categories.parallelStream().filter(cate -> cate.get("subject_pid").equals(0L))
                    .map(menu -> {
                        menu.put("childrenList", getChildrenMenuMap(menu, categories));
                        return menu;
                    }).sorted((menu1, menu2) -> {
                        return Integer.parseInt(String.valueOf(menu1.get("subject_sort"))) - Integer.parseInt(String.valueOf(menu2.get("subject_sort")));
                    }).collect(Collectors.toList());

            return rootCategorys;
        }

        return Collections.emptyList();
    }

    /**
     * 查询所有的子分类
     *
     * @param rootCategory
     * @param allCategorys
     * @return
     */
    private List<Map<String, Object>> getChildrenMenuMap(Map<String, Object> rootCategory, List<Map<String, Object>> allCategorys) {
        List<Map<String, Object>> categoryList = allCategorys.parallelStream().filter(cate -> {
            return cate.get("subject_pid").equals(rootCategory.get("subject_id"));
        }).collect(Collectors.toList());
        return CollectionUtils.isEmpty(categoryList) ? Collections.emptyList() : categoryList;
    }
}